//业务模块

var express = require('express');
var router = express.Router();   // 路由分包

const mongoose = require('mongoose');

// 引入模型
const Business = require('../models/businessSchema');
const Repair = require('../models/repairSchema');

/*   api接口  */

// 业务创建接口 
// 依据前端传过来的业务姓名进行条件查询业务表上的数据返回，依据时间倒序排序 -- 接口 findByInfo

router.post('/findByInfo', function (req, res, next) {
  const { username } = req.body; // 获取前端传递的业务员姓名
  console.log(username);

  if (!username) {
    return res.status(400).json({
      code: 400,
      msg: '缺少业务员姓名参数',
      data: null
    });
  }

  // 查询业务表中的数据，依据业务员姓名进行模糊匹配，并按创建时间倒序排序
  Business.find({ username: { $regex: username, $options: 'i' } })
    .sort({ createdAt: -1 }) // 按创建时间倒序排序
    .then((data) => {
      console.log('业务员数据---查询成功:', data);
      res.status(200).json({
        code: 200,
        msg: '查询成功',
        data: data
      });
    })
    .catch((err) => {
      console.error('Error finding business:', err);
      res.status(500).json({
        code: 500,
        msg: '服务器内部错误',
        data: err.message
      });
    });
});

// module.exports = router;

/*   api接口  */

//业务创建接口 --- 依据前端传过来的业务姓名进行条件查询业务表上的数据返回，依据时间倒序排序 

router.post('/findByInfos', function (req, res, next) {
  const { username } = req.body; // 获取前端传递的业务员姓名

  console.log(username);
  if (!username) {
    return res.status(400).json({
      code: 400,
      msg: '缺少业务员姓名参数',
      data: null
    });
  }

  // 使用聚合框架进行联表查询
  Business.aggregate([
    {
      $match: { username: { $regex: username, $options: 'i' } } // 匹配业务员姓名
    },
    {
      $lookup: {
        from: 'repairs', // 关联的集合名，假设为 repairs
        let: { machineId: { $toObjectId: '$machineId' } }, // 将 machineId 转换为 ObjectId
        pipeline: [
          {
            $match: {
              $expr: { $eq: ['$_id', '$$machineId'] } // 比较 _id 和 machineId
            }
          }
        ],
        as: 'repairs' // 结果字段
      }
    },
    { $sort: { createdAt: -1 } } // 按创建时间倒序排序
  ])
    .then((data) => {
      console.log('业务员数据及维修记录---查询成功:', data);
      res.status(200).json({
        code: 200,
        msg: '查询成功',
        data: data
      });
    })
    .catch((err) => {
      console.error('Error finding business and repairs:', err);
      res.status(500).json({
        code: 500,
        msg: '服务器内部错误',
        data: err.message
      });
    });
});

//接收前端传递的值 把数据进行修改  status
router.post('/updateStatus', function (req, res, next) {
  const { businessId, status } = req.body; // 获取前端传递的 businessId 和 status

  console.log(req.body);

  if (!status || !businessId) {
    return res.status(400).json({
      code: 400,
      msg: '缺少 status 或 businessId 参数',
      data: null
    });
  }

  // 验证 businessId 是否为有效的 ObjectId
  if (!mongoose.Types.ObjectId.isValid(businessId)) {
    return res.status(400).json({
      code: 400,
      msg: 'businessId 不是有效的 ObjectId',
      data: null
    });
  }

  // 使用 updateOne 方法更新 Business 文档
  Business.updateOne(
    { machineId: new mongoose.Types.ObjectId(businessId) }, // 查询条件
    { $set: { status: status } } // 更新操作
  )
    .then((result) => {
      if (result.nModified === 0) {
        return res.status(404).json({
          code: 404,
          msg: '未找到对应的业务记录',
          data: null
        });
      }
      console.log('业务记录更新成功:', result);
      res.status(200).json({
        code: 200,
        msg: '更新成功',
        data: result
      });
    })
    .catch((err) => {
      console.error('Error updating business status:', err);
      res.status(500).json({
        code: 500,
        msg: '服务器内部错误',
        data: err.message
      });
    });
});

///getByMachineId --依据前端传递过来的数据id进行查询数据
router.get('/getByMachineId', function (req, res, next) {
  const { machineId } = req.query; // 获取前端传递的 machineId

  console.log(machineId);

  if (!machineId) {
    return res.status(400).json({
      code: 400,
      msg: '缺少 machineId 参数',
      data: null
    });
  }

  // 验证 machineId 是否为有效的 ObjectId
  if (!mongoose.Types.ObjectId.isValid(machineId)) {
    return res.status(400).json({
      code: 400,
      msg: 'machineId 不是有效的 ObjectId',
      data: null
    });
  }

  // 使用 Business.find 方法查询文档
  Business.find({ machineId: new mongoose.Types.ObjectId(machineId) })
    .then((data) => {
      if (data.length === 0) {
        return res.status(404).json({
          code: 404,
          msg: '未找到对应的业务记录',
          data: null
        });
      }
      console.log('业务记录查询成功:', data);
      res.status(200).json({
        code: 200,
        msg: '查询成功',
        data: data
      });
    })
    .catch((err) => {
      console.error('Error finding business by machineId:', err);
      res.status(500).json({
        code: 500,
        msg: '服务器内部错误',
        data: err.message
      });
    });
});

router.post('/updateMaintenance', function (req, res, next) {
  const { machineId, solution, money, repairDestination } = req.body;

  console.log("接收到的更新数据:", req.body);

  // 参数完整性校验
  if (!machineId || !solution || money === undefined || !repairDestination) {
    return res.status(400).json({
      code: 400,
      msg: '缺少必要参数',
      data: null
    });
  }

  // 验证 machineId 是否为有效的 ObjectId
  if (!mongoose.Types.ObjectId.isValid(machineId)) {
    return res.status(400).json({
      code: 400,
      msg: 'machineId 不是有效的 ObjectId',
      data: null
    });
  }

  // 校验 money 字段是否为合法的布尔值（支持字符串和布尔值）
  let paymentStatus = false;
  if (typeof money === 'string') {
    if (money.toLowerCase() === 'true') {
      paymentStatus = true;
    } else if (money.toLowerCase() === 'false') {
      paymentStatus = false;
    } else {
      return res.status(400).json({
        code: 400,
        msg: 'money 参数值不合法，应为 true 或 false',
        data: null
      });
    }
  } else if (typeof money === 'boolean') {
    paymentStatus = money;
  } else {
    return res.status(400).json({
      code: 400,
      msg: 'money 参数类型不合法，应为布尔值或字符串',
      data: null
    });
  }

  // 执行数据库更新
  Business.updateOne(
    { machineId: new mongoose.Types.ObjectId(machineId) }, // 查询条件
    {
      $set: {
        solution: solution, // 直接映射 solution 字段
        money: paymentStatus, // 将 money 转换为布尔值后映射到 money 字段
        repairDestination: repairDestination, // 直接映射 repairDescription 字段

        updatedAt: new Date() // 添加更新时间戳
      }
    }
  )
    .then((result) => {
      if (result.matchedCount === 0) {
        return res.status(404).json({
          code: 404,
          msg: '未找到对应的业务记录',
          data: null
        });
      }

      console.log('业务记录更新成功:', result);
      res.status(200).json({
        code: 200,
        msg: '更新成功',
        data: {
          matchedCount: result.matchedCount,
          modifiedCount: result.modifiedCount
        }
      });
    })
    .catch((err) => {
      console.error('Error updating business:', err);
      res.status(500).json({
        code: 500,
        msg: '服务器内部错误',
        data: err.message
      });
    });

})

module.exports = router;